home *** CD-ROM | disk | FTP | other *** search
/ MIDICraft's MIDINET CD-ROM / MIDICraft's MIDINET CD-ROM.iso / DOSUTILS / KORGI3 / RECVI3.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-03  |  19.3 KB  |  917 lines
  1. // recvi3: (c) Günter Nagler 1996
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <string.h>
  5. #include "sb.hpp"
  6. #include "korg.hpp"
  7. #include "filei3.hpp"
  8. #include <dir.h>
  9. #include "korgtext.hpp"
  10. #include <alloc.h>
  11.  
  12. Soundcard* card = 0;
  13.  
  14. char outputname[128], *outputext = 0;
  15. unsigned char data[32000];
  16. unsigned char *extra[4] = { 0, 0, 0, 0 };
  17. long len = 0;
  18. int working = 0;
  19. int recording = 0;
  20. int ignoring = 0;
  21.  
  22. #define request_glb   0x0e
  23. #define send_glb      0x51
  24. #define request_dkt   0x0d
  25. #define send_dkt      0x52
  26. #define request_pcg   0x1c
  27. #define send_pcg      0x4c
  28. #define request_sty   0x31
  29. #define send_sty      0x65
  30. #define request_arr   0x30
  31. #define send_arr      0x64
  32. #define request_bsq   0x32
  33. #define send_bsq      0x66
  34. #define request_sng   0x18
  35. #define send_sng      0x48
  36. #define request_all   0x0f
  37. #define send_all      0x50
  38.  
  39. // other korg sysex
  40. #define mode_change   0x4e
  41. #define param_change  0x41
  42. #define send_prog     0x40
  43. #define drumkit_change 0x53
  44.  
  45. int request(Soundcard* card, int dumpmode)
  46. {
  47.   if (!card)
  48.     return 0;
  49.   unsigned char req[6] = { 0xf0, 0x42, 0x30, 0x39, 0xFF, 0xf7 };
  50.  
  51.   req[4] = dumpmode;
  52.   return card->play(req, sizeof(req)) == sizeof(req);
  53. }
  54.  
  55. void record(unsigned char c)
  56. {
  57.   if (len < sizeof(data))
  58.   {
  59.     data[(int)len] = c;
  60.     len++;
  61.   }
  62.   else
  63.   {
  64.     int block = (int)((len / sizeof(data))-1);
  65.     if (block >= 4)
  66.     {
  67.       len++;
  68.       return;
  69.     }
  70.     int idx = (int)(len % sizeof(data));
  71.     if (!extra[block])
  72.     {
  73.       if (idx == 0)
  74.       {
  75.     extra[block] = (unsigned char*)malloc(sizeof(data));
  76.     if (!extra[block])
  77.     {
  78.       fprintf(stderr,"not enough memory to store dump\n");
  79.       ignoring = 1;
  80.       return;
  81.     }
  82.       }
  83.       else
  84.     return;
  85.     }
  86.     extra[block][idx] = c;
  87.     len++;
  88.   }
  89. }
  90.  
  91. unsigned char* accessdata(long i, int* n)
  92. {
  93.   if (i < sizeof(data))
  94.   {
  95.     if (len <= sizeof(data))
  96.       *n = (int)(len-i);
  97.     else
  98.       *n = sizeof(data) - int(i);
  99.     return data + int(i);
  100.   }
  101.   else if (i < len)
  102.   {
  103.     int block = int(i / sizeof(data))-1;
  104.     int idx = (int)(i % sizeof(data));
  105.     long nexti = ((i / sizeof(data))+1) * sizeof(data);
  106.  
  107.     if (len <= nexti)
  108.       *n = (int)(len-i);
  109.     else
  110.       *n = sizeof(data) - idx;
  111.     return extra[block] + idx;
  112.   }
  113.   *n = 0;
  114.   return 0;
  115. }
  116.  
  117. int setdata(unsigned char* s, int n, long i)
  118. {
  119. int maxn;
  120. int sum = 0;
  121.  
  122.   while (n > 0)
  123.   {
  124.     unsigned char* code = accessdata(i, &maxn);
  125.     if (!code)
  126.       return 0;
  127.     if (maxn > n)
  128.       maxn = n;
  129.     memcpy(code, s, maxn);
  130.     s += maxn;
  131.     sum += maxn;
  132.     n -= maxn;
  133.     i += maxn;
  134.   }
  135.   return sum;
  136. }
  137.  
  138. int getdata(unsigned char* s, int n, long i)
  139. {
  140. int maxn;
  141. int sum = 0;
  142.  
  143.   while (n > 0)
  144.   {
  145.     unsigned char* code = accessdata(i, &maxn);
  146.     if (!code)
  147.       return 0;
  148.     if (maxn > n)
  149.       maxn = n;
  150.     memcpy(s, code, maxn);
  151.     s += maxn;
  152.     sum += maxn;
  153.     n -= maxn;
  154.     i += maxn;
  155.   }
  156.   return sum;
  157. }
  158.  
  159. int getword(long i)
  160. {
  161. unsigned char v[2];
  162.  
  163.   getdata(v, 2, i);
  164.  
  165.   return v[0] + (int(v[1]) << 7);
  166. }
  167.  
  168.  
  169. int savedata(FILE* f, long i, long len)
  170. {
  171.   if (!f || i < 0 || len <= 0)
  172.     return 0;
  173.   int n;
  174.   while (len > 0)
  175.   {
  176.     unsigned char* code = accessdata(i, &n);
  177.  
  178.     if (n > len)
  179.       n = (int)len;
  180.     if (fwrite(code, n, 1, f) != 1)
  181.       return 0;
  182.     i += n;
  183.     len -= n;
  184.   }
  185.   return 1;
  186. }
  187.  
  188. long decodedata(long i, long count)
  189. {
  190.   if (i < 0 || count <= 0 || i + count > len)
  191.     return 0;
  192.  
  193.   unsigned char encoded[8];
  194.   unsigned char decoded[7];
  195.   long newi = i;
  196.   long oldi = i;
  197.   int enc, dec;
  198.  
  199.   while (count  > 0)
  200.   {
  201.     if (count > 8)
  202.       enc = 8;
  203.     else
  204.       enc = (int)count;
  205.     getdata(encoded, enc, i);
  206.     dec = code8to7(encoded, enc, decoded);
  207.     setdata(decoded, dec, newi);
  208.     newi += dec;
  209.     count -= enc;
  210.     i += enc;
  211.   }
  212. /*
  213.   count = len - i;
  214.   while (count > 0)
  215.   {
  216.     if (count > 8)
  217.       enc = 8;
  218.     else
  219.       enc = (int)count;
  220.     getdata(encoded, enc, i);
  221.     setdata(encoded, enc, newi);
  222.     i+= enc;
  223.     newi+=enc;
  224.     count -= enc;
  225.   }
  226. */
  227.   return newi-oldi;
  228. }
  229.  
  230. long saveglb(long pos = 5, int encoded = 1)
  231. {
  232.   strcpy(outputext, "GLB");
  233.   FILE* f = fopen(outputname, "wb");
  234.   if (!f)
  235.   {
  236.     perror(outputname);
  237.     return 0;
  238.   }
  239.  
  240.   if (encoded)
  241.     decodedata(pos, 32);
  242.   if (savedata(f, pos, 28) <= 0)
  243.   {
  244.     fprintf(stderr, "error saving global data to %s\n", outputname);
  245.     fclose(f);
  246.     return 0;
  247.   }
  248.   fprintf(stderr, "saved global data to %s\n", outputname);
  249.   fclose(f);
  250.   return encoded ? 32 : 28;
  251. }
  252.  
  253. long savedkt(long pos = 5, int encoded = 1)
  254. {
  255.   strcpy(outputext, "DKT");
  256.   FILE* f = fopen(outputname, "wb");
  257.   if (!f)
  258.   {
  259.     perror(outputname);
  260.     return 0;
  261.   }
  262.  
  263.   if (encoded)
  264.     decodedata(5, 960);
  265.   if (savedata(f, pos, 840) <= 0)
  266.   {
  267.     fprintf(stderr, "error saving drumkit data to %s\n", outputname);
  268.     fclose(f);
  269.     return 0;
  270.   }
  271.   fprintf(stderr, "saved drumkit data to %s\n", outputname);
  272.   fclose(f);
  273.   return encoded ? 960 : 840;
  274. }
  275.  
  276. long savepcg(long pos = 5, int encoded = 1)
  277. {
  278. PCGHEAD head;
  279.  
  280.   memset(&head, 0, sizeof(head));
  281.   memcpy(head.korg, "KORG", 4);
  282.   head.unknown[0] = '9';
  283.  
  284.  
  285.   strcpy(outputext, "PCG");
  286.   FILE* f = fopen(outputname, "wb");
  287.   if (!f)
  288.   {
  289.     perror(outputname);
  290.     return 0;
  291.   }
  292.  
  293.   if (encoded)
  294.     decodedata(pos, 12371);
  295.  
  296.   long ofs = 0x58;
  297.  
  298.   head.b1.adr = ofs; ofs += (head.b1.len = 0);
  299.   head.prognames.adr = ofs; ofs += (head.prognames.len = 10*66);
  300.   head.globals.adr = ofs; ofs += (head.globals.len = 0);
  301.   head.drumkits.adr = ofs; ofs += (head.drumkits.len = 0);
  302.   head.b5.adr = ofs; ofs += (head.b5.len = 0);
  303.   head.progdata.adr = ofs; ofs += (head.progdata.len = 164 * 66);
  304.   head.b7.adr = ofs; ofs += (head.b7.len = 0);
  305.   head.b8.adr = ofs; ofs += (head.b8.len = 0);
  306.   head.b9.adr = ofs; ofs += (head.b9.len = 0);
  307.  
  308.   if (fwrite(&head, sizeof(head), 1,f) != 1)
  309.     return 0;
  310.  
  311.   // program names
  312.   for (long i = pos, j = 0; j < 66; j++, i+= 164)
  313.   {
  314.     if (!savedata(f, i, 10))
  315.       return 0;
  316.   }
  317.  
  318.   if (savedata(f, pos, 164*66) <= 0)
  319.   {
  320.     fprintf(stderr, "error saving program data to %s\n", outputname);
  321.     fclose(f);
  322.     return 0;
  323.   }
  324.   fprintf(stderr, "saved program data to %s\n", outputname);
  325.   fclose(f);
  326.   return encoded ? 12371 : 66*164;
  327. }
  328.  
  329. long savesty(long pos = 5, int encoded = 1)
  330. {
  331. STYHEAD head;
  332.  
  333.   memset(&head, 0, sizeof(head));
  334.   memcpy(head.korg, "KORG", 4);
  335.   head.unknown[0] = '9';
  336.   head.unknown[2] = 4;
  337.   head.stylenames.adr = 0x20;
  338.   head.stylenames.len = 10 * 4;
  339.   head.styletable.adr = 0x48;
  340.   head.styletable.len = sizeof(STYLINK) * 4;
  341.  
  342.   strcpy(outputext, "STY");
  343.   FILE* f = fopen(outputname, "wb");
  344.   if (!f)
  345.   {
  346.     perror(outputname);
  347.     return 0;
  348.   }
  349.   STYLINK style[4];
  350.  
  351.   if (encoded)
  352.   {
  353.     unsigned char buf[28];
  354.     getdata(buf, 28, pos);
  355.     int n = 28;
  356.     unsigned char* b = buf;
  357.     unsigned char* s = (unsigned char*)&style;
  358.     while (n > 0)
  359.     {
  360.       code8to7(b, n, s);
  361.       n -= 8;
  362.       b += 8;
  363.       s += 7;
  364.     }
  365.   }
  366.   else
  367.     getdata((unsigned char*)style, sizeof(style), pos);
  368.  
  369.   long decsize = long(style[0].len) + long(style[1].len) +
  370.          long(style[2].len) + long(style[3].len) + 24;
  371.   long encsize = (decsize / 7) * 8 + (decsize % 7) + 1;
  372.   if (encoded)
  373.      decodedata(pos, encsize);
  374.  
  375.   if (fwrite(&head, 0x20, 1,f) != 1)
  376.     return 0;
  377.  
  378.   int j = 0;
  379.   for (long i = pos, k = pos+4*6; j < 4; j++, i+= 6)
  380.   {
  381.     if (!savedata(f, k, 10))
  382.       return 0;
  383.     k += style[j].len;
  384.   }
  385.  
  386.   if (savedata(f, pos, decsize) <= 0)
  387.   {
  388.     fprintf(stderr, "error saving style data to %s\n", outputname);
  389.     fclose(f);
  390.     return 0;
  391.   }
  392.   fprintf(stderr, "saved style data to %s\n", outputname);
  393.   fclose(f);
  394.   return encoded ? encsize : decsize;
  395. }
  396.  
  397. long savearr(long pos = 5, int encoded = 1)
  398. {
  399. ARRHEAD head;
  400.  
  401.   memset(&head, 0, sizeof(head));
  402.   memcpy(head.korg, "KORG", 4);
  403.   head.unknown[0] = '9';
  404.   head.unknown[2] = 3;
  405.   head.arrnames.adr = 0x20;
  406.   head.arrnames.len = 10 * 64;
  407.   head.arrdata.adr = 0x2a0;
  408.   head.arrdata.len = 64 * 131;
  409.  
  410.   strcpy(outputext, "ARR");
  411.   FILE* f = fopen(outputname, "wb");
  412.   if (!f)
  413.   {
  414.     perror(outputname);
  415.     return 0;
  416.   }
  417.  
  418.   if (encoded)
  419.     decodedata(pos, 9582);
  420.  
  421.   if (fwrite(&head, 0x20, 1,f) != 1)
  422.     return 0;
  423.  
  424.   for (long i = pos, j = 0; j < 64; j++, i+= 131)
  425.   {
  426.     if (!savedata(f, i, 10))
  427.       return 0;
  428.   }
  429.  
  430.   if (savedata(f, pos, 131*64) <= 0)
  431.   {
  432.     fprintf(stderr, "error saving arrangement data to %s\n", outputname);
  433.     fclose(f);
  434.     return 0;
  435.   }
  436.   fprintf(stderr, "saved arrangement data to %s\n", outputname);
  437.   fclose(f);
  438.   return encoded ? 9582 : 131*64;
  439. }
  440.  
  441. long savebsq(long pos = 7, unsigned steps = 0, int encoded = 1)
  442. {
  443. BSQHEAD head;
  444.  
  445.   memset(&head, 0, sizeof(head));
  446.   memcpy(head.korg, "KORG", 4);
  447.   head.unknown[0] = '9';
  448.   head.unknown[2] = 1;
  449.   head.unknown[3] = 1;
  450.  
  451.   strcpy(outputext, "BSQ");
  452.   FILE* f = fopen(outputname, "wb");
  453.   if (!f)
  454.   {
  455.     perror(outputname);
  456.     return 0;
  457.   }
  458.  
  459.   long decsize = 2292 + 16l * steps;
  460.   long encsize = (decsize / 7) * 8 + (decsize % 7) + 1;
  461.  
  462.   if (encoded)
  463.     decodedata(pos, encsize);
  464.  
  465.   for (long i = pos+0x79e, j = 0; j < 171; j++, i+=2)
  466.   {
  467.     unsigned v;
  468.  
  469.     getdata((unsigned char*)&v, 2, i);
  470.     v += 15;                           // don't know why
  471.     setdata((unsigned char*)&v, 2, i);
  472.   }
  473.  
  474.   if (fwrite(&head, 0x10, 1,f) != 1)
  475.     return 0;
  476.  
  477.   if (savedata(f, pos, decsize) <= 0)
  478.   {
  479.     fprintf(stderr, "error saving backing sequence data to %s\n", outputname);
  480.     fclose(f);
  481.     return 0;
  482.   }
  483.   fprintf(stderr, "saved backing sequence data to %s\n", outputname);
  484.   fclose(f);
  485.   return encoded  ? encsize : decsize;
  486. }
  487.  
  488. long savesng(long pos = 7, unsigned steps = 0, int encoded = 1)
  489. {
  490. SNGHEAD head;
  491.  
  492.   memset(&head, 0, sizeof(head));
  493.   memcpy(head.korg, "KORG", 4);
  494.   head.unknown[0] = '9';
  495.   head.unknown[1] = 1;
  496.   head.unknown[2] = 1;
  497.  
  498.   strcpy(outputext, "SNG");
  499.   FILE* f = fopen(outputname, "wb");
  500.   if (!f)
  501.   {
  502.     perror(outputname);
  503.     return 0;
  504.   }
  505.  
  506.   long decsize = 3702 + 16l * steps;
  507.   long encsize = (decsize / 7) * 8 + (decsize % 7) + 1;
  508.  
  509.   if (encoded)
  510.     decodedata(pos, encsize);
  511.  
  512.   for (long i = pos + 0xc58, j = 0; j < 271; j++, i+=2)
  513.   {
  514.     unsigned v;
  515.  
  516.     getdata((unsigned char*)&v, 2, i);
  517.     v += 15;                           // don't know why
  518.     setdata((unsigned char*)&v, 2, i);
  519.   }
  520.  
  521.   if (fwrite(&head, 0x10, 1,f) != 1)
  522.     return 0;
  523.  
  524.   if (savedata(f, pos, decsize) <= 0)
  525.   {
  526.     fprintf(stderr, "error saving song data to %s\n", outputname);
  527.     fclose(f);
  528.     return 0;
  529.   }
  530.   fprintf(stderr, "saved song data to %s\n", outputname);
  531.   fclose(f);
  532.   return encoded ? encsize : decsize;
  533. }
  534.  
  535. long saveall(long pos = 5)
  536. {
  537. long oldpos = pos;
  538.  
  539.   unsigned bseqsteps, songsteps;
  540.  
  541.   songsteps = getword(pos); pos += 2;
  542.   bseqsteps = getword(pos); pos += 2;
  543.  
  544.   long declen= decodedata(pos, len-pos-1);
  545.  
  546.   pos += saveglb(pos, 0);
  547.   pos += savedkt(pos, 0);
  548.   pos += savepcg(pos, 0);
  549.   pos += savearr(pos, 0);
  550.   pos += savesty(pos, 0);
  551.   pos += savesng(pos, songsteps, 0);
  552.   pos += savebsq(pos, bseqsteps, 0);
  553.   return pos-oldpos;
  554. }
  555.  
  556. void saverecording()
  557. {
  558. unsigned steps = 0;
  559.  
  560.   switch(data[4])
  561.   {
  562.   case send_glb:
  563.     saveglb();
  564.     break;
  565.   case send_dkt:
  566.     savedkt();
  567.     break;
  568.   case send_pcg:
  569.     savepcg();
  570.     break;
  571.   case send_sty:
  572.     savesty();
  573.     break;
  574.   case send_arr:
  575.     savearr();
  576.     break;
  577.   case send_bsq:
  578.     steps = getword(5);
  579.     savebsq(7, steps);
  580.     break;
  581.   case send_sng:
  582.     steps = getword(5);
  583.     savesng(7, steps);
  584.     break;
  585.   case send_all:
  586.     saveall();
  587.     break;
  588.   }
  589. }
  590.  
  591. void unknownsysex()
  592. {
  593.   if (data[1] == 0x7e && data[3] == 6 && data[4] == 2)
  594.   {
  595.     printf("identification: ");
  596.     for (int i = 0; i < len; i++)
  597.       printf(" %02X", data[i]);
  598.     printf("\n");
  599.     printf("Manufacturer id: %02X", data[5]);
  600.     int known = 0;
  601.  
  602.     switch(data[5])
  603.     {
  604.     case 1: printf(" Sequential Circuits"); break;
  605.     case 2: printf(" Big Briar"); break;
  606.     case 3: printf(" Octave / Plateau"); break;
  607.     case 4: printf(" Moog"); break;
  608.     case 5: printf(" Passport Designs"); break;
  609.     case 6: printf(" Lexicon"); break;
  610.     case 0x11: printf(" PAIA"); break;
  611.     case 0x12: printf(" Simmons"); break;
  612.     case 0x13: printf(" Gentle Electric"); break;
  613.     case 0x14: printf(" Fairlight"); break;
  614.     case 0x20: printf(" Bontempi"); break;
  615.     case 0x21: printf(" S.I.E.L"); break;
  616.     case 0x23: printf(" SyntheAxe"); break;
  617.     case 0x40: printf(" Kawai"); break;
  618.     case 0x41: printf(" Roland"); break;
  619.     case 0x42: printf(" Korg"); known = 1; break;
  620.     case 0x43: printf(" Yamaha"); break;
  621.     }
  622.     printf("\n");
  623.     int v = getword(6);
  624.     printf("Family code: %02Xh ", v);
  625.     if (known && v == 0x39)
  626.        printf(" i2/i3");
  627.     else
  628.        known = 0;
  629.     printf("\n");
  630.     v = getword(8);
  631.     printf("Member code: %02Xh ", v);
  632.     if (known && v == 0)
  633.        printf(" i3");
  634.     else if (known && v == 1)
  635.        printf(" i2");
  636.     else
  637.        known = 0;
  638.     printf("\n");
  639.     v = getword(8);
  640.     printf("ROM No: %02Xh (%d)\n", v, v);
  641.     v = getword(10);
  642.     printf("Software Version: %02Xh (%d)\n", v, v);
  643.   }
  644.   else
  645.   {
  646.     printf("unknown system exclusive message ");
  647.     for (int i = 0; i < 5; i++)
  648.       printf(" %02X", data[i]);
  649.     printf(" ... F7\n");
  650.   }
  651. }
  652.  
  653. int receivedump(int what = -1)
  654. {
  655. static unsigned char hearbuf[1024];
  656. int hearlen;
  657. unsigned char c;
  658. int v;
  659. unsigned steps;
  660.  
  661.  
  662.   card->startinput();
  663.   while (!kbhit() || getch() != 27)
  664.   {
  665.     if ((hearlen = card->hear(hearbuf, sizeof(hearbuf))) <= 0)
  666.       continue;
  667.     working = 1;
  668.     for (int i = 0; i < hearlen; i++)
  669.     {
  670.       c = hearbuf[i];
  671.       if (c == 0xf8 || c == 0xfe)
  672.     continue;
  673.       if (!recording)
  674.       {
  675.     if (c == 0xf0)
  676.     {
  677.       recording = 1;
  678.       ignoring = 0;
  679.       len = 0;
  680.       record(c);
  681.     }
  682.     continue;
  683.       }
  684.       // recording
  685.       if (len % 1000 == 0)
  686.     fprintf(stderr, "%ld\r", len);
  687.  
  688.       if (len == 100)
  689.       {
  690.     if (data[1] != 0x42 || data[2] != 0x30  || data[3] != 0x39)
  691.       ignoring = 1; // unknown sysex
  692.     else if (what >= 0 && data[4] != what)
  693.       ignoring = 1;
  694.       }
  695.       if (!ignoring)
  696.       {
  697.      record(c);
  698.       }
  699.       if (c == 0xf7)
  700.       {
  701.     printf("%ld bytes received: ", len);
  702.     recording = 0;
  703.  
  704.     if (data[1] != 0x42 || data[2] != 0x30)
  705.     {
  706.       unknownsysex();
  707.       if (data[1] == 0x7e && data[3] == 6 && data[4] == 2)
  708.         ungetch(27);
  709.     }
  710.     else
  711.     {
  712.       switch(data[4])
  713.       {
  714.       case send_glb:
  715.         printf("global data dump\n");
  716.         break;
  717.       case send_dkt:
  718.         printf("drumkit data dump\n");
  719.         break;
  720.       case send_pcg:
  721.         printf("all program data dump\n");
  722.         break;
  723.       case send_sty:
  724.         printf("all style data dump\n");
  725.         break;
  726.       case send_arr:
  727.         printf("all arrangement data dump\n");
  728.         break;
  729.       case send_bsq:
  730.         steps = data[5] + (data[6] << 7);
  731.         printf("all backing sequence data dump (%d steps)\n", steps);
  732.         break;
  733.       case send_sng:
  734.         steps = data[5] + (data[6] << 7);
  735.         printf("all song data dump (%d steps)\n", steps);
  736.         break;
  737.       case send_all:
  738.         printf("all data dump\n");
  739.         break;
  740.       case mode_change:
  741.         printf("mode changed to %s\n", kbdmode(data[5]));
  742.         break;
  743.       case param_change:
  744.         v = (int(data[9]) << 7) + data[8];
  745.         if (v & 0x2000)
  746.           v = v-0x4000;
  747.         printf("parameter changed in Page %d Stage %d Position %d to Value %d\n",
  748.           data[5], data[6], data[7], v);
  749.         break;
  750.       case send_prog:
  751.         unsigned char name[14];
  752.         code8to7(data+5, 8, name);
  753.         code8to7(data+5+8, 8, name+7);
  754.         printf("program data dump %-10.10s\n", name);
  755.         break;
  756.  
  757.       case drumkit_change:
  758.         v = (int(data[9]) << 7) + data[8];
  759.         if (v & 0x2000)
  760.           v = v-0x4000;
  761.         printf("drumkit parameter changed in Dr%d Param %d to Value %d\n",
  762.           data[5]+1, data[6], v);
  763.         break;
  764.       default:
  765.         unknownsysex();
  766.         break;
  767.       }
  768.     }
  769.  
  770.     if (!ignoring)
  771.     {
  772.       saverecording();
  773.       if (what >= 0 && data[4] == what) // finished automatically
  774.       {
  775.         hearlen = 0;
  776.         ungetch(27);
  777.         break;
  778.       }
  779.     }
  780.       }
  781.     }
  782.   }
  783.   card->stopinput();
  784.   return working != 0;
  785. }
  786.  
  787. void checkresponse()
  788. {
  789. #define RETRY   1000
  790.  
  791.   card->startinput();
  792.  
  793.   for (long i = 0; i < RETRY; i++)
  794.   if (card->hear(data, 1))
  795.      break;
  796.   if (i == RETRY)
  797.     fprintf(stderr, "Warning: no response from KORG. Transfer might not work.\n");
  798.   else
  799.     fprintf(stderr, "KORG responded\n");
  800.  
  801.   card->stopinput();
  802. }
  803.  
  804. int main(int argc, char** argv)
  805. {
  806. int requestid = -1;
  807. int sendid = -1;
  808. int identify = 0;
  809.  
  810.   argc--; argv++;
  811.   while (argc > 0 && **argv == '-')
  812.   {
  813.     if (strnicmp(*argv, "-h", 2) == 0 || strcmp(*argv ,"-?") == 0)
  814.     {
  815.       printf("usage: recvi3 [-identify] [filename]\n");
  816.       printf("-identify\trequest identification of KORG i3 keyboard\n");
  817.       printf("filename\tshould have extension *,PCG,STY,ARR,SNG,BSQ,GLB,DKT\n");
  818.       printf("When no filename specified then dump must be sent manually\n");
  819.       return 1;
  820.     }
  821.     if (strnicmp(*argv, "-identify", 2) == 0)
  822.     {
  823.       identify = 1;
  824.       argc--; argv++; continue;
  825.     }
  826.     fprintf(stderr, "invalid option %s\n", *argv);
  827.     argc--; argv++;
  828.   }
  829.   if (argc > 0)
  830.   {
  831.     strcpy(outputname, *argv++); argc--;
  832.     char* ext = strrchr(outputname, '.');
  833.     if (ext)
  834.     {
  835.       ext++;
  836.       if (stricmp(ext, "glb") == 0)
  837.       {
  838.     requestid = request_glb;
  839.     sendid = send_glb;
  840.       }
  841.       else if (stricmp(ext, "dkt") == 0)
  842.       {
  843.     requestid = request_dkt;
  844.     sendid = send_dkt;
  845.       }
  846.       else if (stricmp(ext, "pcg") == 0)
  847.       {
  848.     requestid = request_pcg;
  849.     sendid = send_pcg;
  850.       }
  851.       else if (stricmp(ext, "sty") == 0)
  852.       {
  853.     requestid = request_sty;
  854.     sendid = send_sty;
  855.       }
  856.       else if (stricmp(ext, "arr") == 0)
  857.       {
  858.     requestid = request_arr;
  859.     sendid = send_arr;
  860.       }
  861.       else if (stricmp(ext, "bsq") == 0)
  862.       {
  863.     requestid = request_bsq;
  864.     sendid = send_bsq;
  865.       }
  866.       else if (stricmp(ext, "sng") == 0)
  867.       {
  868.     requestid = request_sng;
  869.     sendid = send_sng;
  870.       }
  871.       else if (stricmp(ext, "*") == 0)
  872.       {
  873.     requestid = request_all;
  874.     sendid = send_all;
  875.       }
  876.       else
  877.     fprintf(stderr, "unknown korg extenxion %s ignored\n", ext);
  878.       *ext = 0;
  879.     }
  880.     else
  881.       strcat(outputname, ".");
  882.   }
  883.   else
  884.     strcpy(outputname, "KORGI3.");
  885.   outputext = outputname + strlen(outputname);
  886.   strupr(outputname);
  887.   card = detect_soundcard();
  888.   if (!card)
  889.   {
  890.     fprintf(stderr, "Could not detect soundcard\n");
  891.     return 1;
  892.   }
  893.  
  894.   checkresponse();
  895.  
  896.   if (identify)
  897.   {
  898.     card->play("\xf0\x7e\x00\x06\x01\xf7", 6);
  899.     fprintf(stderr, "requesting identification\n");
  900.     requestid = -1;
  901.     sendid = -1;
  902.   }
  903.   else if (requestid >= 0)
  904.     fprintf(stderr, "requesting dump from korg\n");
  905.   else
  906.     fprintf(stderr, "waiting for receiving korg dumps. press <esc> to abort\n");
  907.   if (requestid >= 0 && !request(card, requestid))
  908.   {
  909.     fprintf(stderr, "requesting dump failed. start dump manually\n");
  910.   }
  911.  
  912.   int ret = receivedump(sendid);
  913.  
  914.   delete card;
  915.   return ret;
  916. }
  917.